Úkol č. 1 - vizualizace dat a web scraping (do 11. října)

• V rámci tohoto úkolu musíte stáhnout dat z webu (tzv. web scraping, velmi základní) a následně data zpracovat a vizualizovat.
• Cílem bude stáhnout data ze serveru https://www.psp.cz/sqw/hlasovani.sqw?o=8 týkající hlasování současné poslanecké sněmovny, uložit tato data v tabulkovém formátu a pak vymyslet vizualizace a zobrazení dat, které umožní orientaci v těchto datech a zvýrazní zajímavé informace a zobrazit přehledně časový vývoj různých veličin.

Úkoly jsou zadány tak, aby Vám daly prostor pro invenci. Vymyslet jak přesně budete úkol řešit, je důležitou součástí zadání a originalita či nápaditost bude také hodnocena!

Data

• Měli byste stáhnout data ze všech hlasování současné poslanecké sněmovny (tj. od voleb v roce 2017) a to až na úroveň jednotlivých poslanců.
• Data by měla obsahovat i stručný popis toho, o jaké hlasování šlo.

Pokyny k vypracování

Základní body zadání, za jejichž (poctivé) vypracování získáte 8 bodů:

• Strojově stáhněte data a uložte je do vhodného formátu, který se Vám bude dále dobře zpracovávat.
• I když nemusíte mít sněmovnu rádi, snažte se nezahltit server a mezi požadavky na stránku mějte alespoň vteřinu mezeru.
• V druhé části Vašeho Jupyter notebooku pracujte se staženými daty v souborech, které jsou výsledkem Vašeho stahovacího skriptu (aby opravující nemusel spouštět stahování z webu).
• S využitím vybraných nástrojů zpracujte data a vymyslete vizualizace a grafy, aby bylo vidět následující:
  • Odchody a přeběhnutí poslanců mezi jednotlivými stranami.
  • Jakou mají jednotliví poslanci docházku (účast na hlasování) a jak jsou na tom s docházkou strany jako celek.
  • Jak často spolu jednotlivé strany hlasují ve shodě a jak často hlasují odlišně.
  • Jak jsou poslanci jednotlivých stran jednotní v hlasování (jak často hlasují stejně, kdo jsou největší rebelové).

Další body zadání za případné další body (můžete si vybrat, maximum bodů za úkol je každopádně 12 bodů):

• Ve vizualizacích a grafech nějak zachyťte časový vývoj (např. jak se mění docházka, shoda mezi stranami atp.).
• Najděte jednotlivé poslance, kteří se nejvíce shodují při svém hlasování či kteří mají co nejpodobnější účast na hlasování.
• Zkuste rozlišit v datech důležitá hlasování a zpracujte vizualizace (také) pro ně.
• Zkuste najít hlasování, kde poslanci hlasovali nejvíce jinak, než obvykle.

Tipy a triky

• Balíčky iportujte na začátku notebooku (příp. na začátku scrapovací a pak na začátku vizualizační části).
• Využívejte markdown buňky (jako je ta, ve které je tento text) a naspisy, abyste usnadnily orientaci opravující(mu).
• Pečlivě si vybírejte grafy a vizualizace, aby co nejlépe vyjádřily to, co vyjádřit chcete. Doporučuji projít si pro inspiraci alespoň galerie balíčků matplotlib a seaborn.

Poznámky k odevzdání

• Řiďte se pokyny ze stránky https://courses.fit.cvut.cz/BI-VZD/homeworks/index.html.
• Odevzdejte Jupyter Notebook (příp. doplněn skripty), ale i soubor(y) se staženými daty (ať opravující nemusí stahovat data).
• Opravující Vám může umožnit úkol dodělat či opravit a získat tak další body. První verze je ale důležitá a bude-li odbytá, budete za to penalizováni.

from bs4 import BeautifulSoup
import numpy as np
import requests
import time
import re
import pandas as pd
import plotly           
import plotly.express as px
import plotly.io as pio
from plotly.subplots import make_subplots
import plotly.graph_objects as go
import seaborn as sns
import matplotlib
import matplotlib.pyplot as plt

Stahovací část

Nejprve jsou pomocí funkce find_all_meeting_link na hlavní stránce nalezeny odkazy na všechny schůze sněmovny. Na odkazu schůze jsou jednotlivá hlasování ještě seskupena, takže najdeme první odkaz na hlasování (find_first_voting). Odtud se již dostaneme k seznamu hlasování dané schůze a shromáždíme odkazy na jednotlivá hlasování(find_all_voting_link)

Nakonec procházíme jednotlivá hlasování, u kterých získáváme jednotlivé hlasy(get_votes) a "lepíme" k nim detaily daného hlasování tj. číslo schůze, číslo hlasování, rozparsované datum, krátký popis hlasování (get_voting_details)

URL = "https://www.psp.cz/sqw/"
MAIN_PAGE = "hlasovani.sqw?o=8"

MONTH_MAP = {
    "ledna": 1,
    "února": 2,
    "března": 3,
    "dubna": 4,
    "května": 5,
    "června": 6,
    "července": 7,
    "srpna": 8,
    "září": 9,
    "října": 10,
    "listopadu": 11,
    "prosince": 12,
}

def get_voting_details(soup):
    header = soup.find( "h1", class_ = "page-title-x" )
    parsed_data = re.split('(\d+)', header.text)
    
    month_name = parsed_data[6][1:].replace('\xa0', '')
    
    return {
        "meeting_id": parsed_data[1],
        "voting_number": parsed_data[3],
        "day": parsed_data[5],
        "month": MONTH_MAP[month_name],
        "year": parsed_data[7],
        "hour": parsed_data[9],
        "minute": parsed_data[11],
        "voting_description": ''.join(parsed_data[12:])
    }

def get_votes( link ):
    votes = []
    page_soup = get_soup( link )
    
    voting_details = get_voting_details(page_soup)
    
    votes_by_party = page_soup.find_all( "ul", class_ = "results" )
    
    for party_votes in votes_by_party:
        party = party_votes.previous_sibling.text.split()[0]
        for vote in party_votes.find_all("li"):
            table_row = {
                "party":party,
                "vote_code": vote.span.text,
                "member_name": vote.find("a").text,
                "member_id": re.findall('\d+', vote.find("a").get("href"))[0]
            }
            table_row.update(voting_details)
            votes.append(table_row)
    
    table = pd.DataFrame(votes)
    return table
            
    

def find_all_voting_link(link):
    all_votings = []
    
    while link:
        page_soup = get_soup(link)
        table = page_soup.find("table")
    
        for row in table.find_all('tr')[1:]:
            all_votings += row.find_all('td')[1]
        
        next_link = page_soup.find( "a", class_ = "next" )
            
        link = next_link.get("href") if next_link else None
        
    return [voting.get("href") for voting in all_votings]

def get_soup(link):
    time.sleep(1)
    response = requests.get(URL + link)
    response.raise_for_status()
    return BeautifulSoup(response.text, "html.parser")

def find_all_meeting_link(link):
    page_soup = get_soup(link)
    all_meetings = page_soup.find_all("a", text=re.compile("[0-9]+\.\xa0schůze"))
    return [meeting.get("href") for meeting in all_meetings]

def find_first_voting(link):
    first_voting = get_soup(link).find("a", href=re.compile("phlasa.*"))
    return first_voting.get("href")


csv = pd.DataFrame()

for meeting_link in find_all_meeting_link(MAIN_PAGE):
    print(meeting_link)
    first_link = find_first_voting(meeting_link)
    for voting_link in find_all_voting_link(first_link):
        csv = pd.concat( [csv, get_votes(voting_link)], ignore_index=True, sort=False)

csv.to_csv(r'export_dataframe.csv', header=True)

Načtení dat

data = pd.read_csv('export_dataframe.csv', index_col=None)

Úprava dat

• Pro snadnější práci s datumem si vytvoříme jeden sloupec s jednotným formátem
• Trochu smysluplnější název pro první sloupec
• Jelikož jsem až po stáhnutí dat zjistil, že na stránce jednotlivých hlasování není vyplněn název hlasování v případě procedurálního hlasování, tak jsem to zde jen doplnil

data['date_time'] = pd.to_datetime(data[['year', 'month', 'day', 'hour', 'minute']])
data.rename(columns={'Unnamed: 0': 'vote_id'}, inplace=True)
data['voting_description'].fillna('Procedurální hlasování', inplace=True)

• Při pozdější práci s daty jsem si všiml, že nějak nesedí datum u čtrnácté schůze

data[(data['meeting_id'].isin([13,14,15,16])) & (data['voting_number'] == 1) & (data['member_id'] == 6150)]

	vote_id	party	vote_code	member_name	member_id	meeting_id	voting_number	day	month	year	hour	minute	voting_description	date_time
128201	128201	ANO	0	Andrej Babiš	6150	13	1	22	5	2018	14	2	Procedurální hlasování	2018-05-22 14:02:00
175001	175001	ANO	M	Andrej Babiš	6150	14	1	4	6	2020	20	53	Pořad schůze	2020-06-04 20:53:00
175401	175401	ANO	M	Andrej Babiš	6150	15	1	14	6	2018	9	2	Procedurální hlasování	2018-06-14 09:02:00
175801	175801	ANO	A	Andrej Babiš	6150	16	1	26	6	2018	14	7	Procedurální hlasování	2018-06-26 14:07:00

• V sloupci date_time je uvedeno, že 14. schůze proběhla o přibližně dva roky později nežli schůze 13.,15. a 16.

• Pravděpodně se zde jedná pouze o chybu v zadání roku, protože jak si můžeme všimnout tak kdyby byl zadán rok 2018 tak by na sebe hlasování navazovala.

• Bohužel tato chyba má trochu rozsáhlejší důsledky

• Následující tabulka ukazuje, že během 14. shůze je počet nezařazených poslanců 5. Ale na schůzích 15. - 27. se nezařazení poslanci vůbec nevyskytují.

• Je velmi nepravděpodobné, že by poslanci svou stranu opustili pouze na jednu schůzi. S největší pravděpodobností je tedy na stránkách zobrazeno rozdělení poslanců k (chybnému) datu 14. schůze.

wrong_date = data[data['voting_number'] == 1]
wrong_date = wrong_date.groupby(['meeting_id', 'party']).size().reset_index()
wrong_date[wrong_date['party'] == 'Nezařaz']

	meeting_id	party	0
111	14	Nezařaz	5
220	28	Nezařaz	4
230	29	Nezařaz	5
240	30	Nezařaz	5
250	31	Nezařaz	5
260	32	Nezařaz	5
270	33	Nezařaz	5
280	34	Nezařaz	5
290	35	Nezařaz	5
300	36	Nezařaz	5
310	37	Nezařaz	5
320	38	Nezařaz	5
330	39	Nezařaz	5
340	40	Nezařaz	5
350	41	Nezařaz	6
360	42	Nezařaz	6
370	43	Nezařaz	5
380	44	Nezařaz	5
390	45	Nezařaz	5
400	46	Nezařaz	5
410	47	Nezařaz	5
420	48	Nezařaz	5
430	49	Nezařaz	5
440	50	Nezařaz	5
450	51	Nezařaz	5
460	52	Nezařaz	5
470	53	Nezařaz	5
480	54	Nezařaz	5
490	55	Nezařaz	5
500	56	Nezařaz	5
510	57	Nezařaz	6
520	58	Nezařaz	6
530	59	Nezařaz	6

data[(data['meeting_id']==14) & (data['member_id'] == 6150)]

	vote_id	party	vote_code	member_name	member_id	meeting_id	voting_number	day	month	year	hour	minute	voting_description	date_time
175001	175001	ANO	M	Andrej Babiš	6150	14	1	4	6	2020	20	53	Pořad schůze	2020-06-04 20:53:00
175201	175201	ANO	M	Andrej Babiš	6150	14	2	4	6	2020	20	55	Pořad schůze	2020-06-04 20:55:00

• Protože ke 14. schůzi jsou dostupná pouhá dvě hlasování o pořadu schůze, rozhodl jsem se tuto schůzi z dat odstranit. Alternativně jsem mohl chybně zařazené poslance přidělit do správných stran a opravit datum schůze.

data = data[data['meeting_id'] != 14]

Alternativní řešení:

# data.loc[data['meeting_id'] == 14, 'year'] = 2018
# data['date_time'] = pd.to_datetime(data[['year', 'month', 'day', 'hour', 'minute']])

# wrong_members = data[(data['meeting_id']==14) & (data['party'] == 'Nezařaz')]['member_id'].unique()
# right_members = data[(data['meeting_id']==13) & (data['voting_number']==1)].copy()


# for member_id in wrong_members:
#     for voting_number in data[data['meeting_id']==14]['voting_number'].unique():
#         data.loc[(data['meeting_id'] == 14) & (data['member_id'] == member_id) & (data['voting_number'] == voting_number), 'party'] = right_members[right_members['member_id'] == member_id]['party'].values

    
# # data[(data['meeting_id']==14) & (data['member_id'].isin(wrong_members))]

Příchozí/odchozí poslanci

• V této části nejsou zahrnuti poslanci, kteří stranu změnili (o nich více v části Přeběhlíci)
• Zde tedy identifikujeme poslance, kteří v nějakém bodě přestali být poslanci za danou stranu (to však automaticky neznamená, že ze strany vystoupili viz. např. Jaroslava Pokorná Jermanová) a jejich náhradníky

Vzhledem k tomu, že máme k dispozici unikátní identifikátor poslanců budeme pro jednoduchost pracovat pouze s ním a až budeme mít požadovanou množinu přijoinuje detaily poslanců(jméno, příjmení atd.)

Zjistit, kteří poslanci ze sněmovny odešli je vcelku jednoduché. Nejprve zjistíme ID všech poslanců (all_members). Dále seřadíme data podle čísla schůze a čísla hlasování a zjistíme ID poslanců kteří byli členy sněmovny při posledním hlasování (ending_members). Rozdílem množin all_members a ending_members získáme ID odchodzích poslanců. Teď již stačí jen k jednotlivým ID doplnit detaily a udělat z toho nějaký pěkný graf.

V případě příchozích poslanců postupujeme analogicky pouze vezmeme poslance nikoli z posledního, ale z prvního hlasování.

NUM_OF_MEMBERS = 200

all_members_info = data.groupby(['member_id', 'member_name', 'party']).size().reset_index()
    
data.sort_values(by = ['meeting_id', 'voting_number'], inplace = True)
starting_members = set(data.head(NUM_OF_MEMBERS)['member_id'])
    
ending_members = set(data.tail(NUM_OF_MEMBERS)['member_id'])

all_members = set(data['member_id'].unique())

leaving_members = pd.Series(list(all_members - ending_members), name = 'member_id')

coming_members = pd.Series(list(all_members - starting_members), name = 'member_id')

leaving_members = pd.merge(all_members_info, leaving_members, on=['member_id']).drop(0, 1)

coming_members = pd.merge(all_members_info, coming_members, on=['member_id']).drop(0, 1)

• Úprava paní Jermanové, jelikož má příliš dlouhé jméno a kazila vzhled grafu

leaving_members.loc[leaving_members['member_name'].str.contains('Jermanová'),'member_name'] =\
'Jaroslava Pokorná <br> Jermanová'   

barchart = px.bar(
    data_frame=leaving_members,
    
    x='party',
    color='party',             
    opacity=1,                
    orientation='v',              
    barmode='relative',
    text = 'member_name',
    title = 'Odchozí poslanci',
    labels={'count':'Počet odchozích', 'party': ''}, 
    color_discrete_map={'ČSSD': 'orange' ,'ODS':'blue', 'KSČM':'red', 'Piráti':'black', 'ANO':'aqua', 'STAN':'green'})

barchart.update_traces(showlegend=False)
barchart.update_layout(xaxis={'categoryorder':'array', 'categoryarray':['ANO','ČSSD','ODS','Piráti','KSČM','STAN']})


pio.show(barchart)

barchart = px.bar(
    data_frame=coming_members,
    
    x='party',
    color='party',             
    opacity=1,                
    orientation='v',              
    barmode='relative',
    text = 'member_name',
    title = 'Příchozí poslanci',
    labels={'count':'Počet příchozích', 'party': ''}, 
    color_discrete_map={'ČSSD': 'orange' ,'ODS':'blue', 'KSČM':'red', 'Piráti':'black', 'ANO':'aqua', 'STAN':'green'})

barchart.update_traces(showlegend=False)
barchart.update_layout(xaxis={'categoryorder':'array', 'categoryarray':['ANO','ČSSD','ODS','Piráti','KSČM','STAN']})


pio.show(barchart)

Přeběhlíci

• Zde jsou vypsáni jednotliví poslanci, kteří svou stranu opustili nebo přeběhli do jiné

switched_members = data.groupby(['member_id', 'member_name', 'party']).size().reset_index().groupby(['member_id', 'member_name']).count().reset_index()
switched_members = switched_members[switched_members['party'] > 1]
switched_members['member_name']

27                 Jaroslav Foldyna
105                    Marian Bojko
121                  Tereza Hyťhová
132    Zuzana Majerová Zahradníková
143                 Ivana Nevludová
146                   Lubomír Volný
163                    Václav Klaus
Name: member_name, dtype: object

• Příprava dat k animaci

switched_animation_data = data[(data['voting_number'] == 1) & (data['meeting_id'] > 25)]
switched_animation_data = switched_animation_data.groupby(['meeting_id', 'party']).size().reset_index()
switched_animation_data = switched_animation_data.rename(columns = {0:'num_of_members'})

missing_frames = pd.DataFrame({'meeting_id':[26,27], 'party':['Nezařaz','Nezařaz'], 'num_of_members':[0,0]})

switched_animation_data = switched_animation_data.append(missing_frames, ignore_index=True)

• Zde je již časový vývoj počtu poslanců jednotlivých stran. Časově je řazeno po jednotlivých schůzcích a jelikož opouštění/přebíhání začalo až s 28. schůzí jsou vynechány shůze 1.-25.

• Nejedná se o zrovna dramatický vývoj

switched_animation = px.bar(
    data_frame = switched_animation_data,
    x = 'party',
    y = 'num_of_members',
    color='party',
    animation_frame= 'meeting_id',
    animation_group='party',
    labels={'num_of_members':'Počet členů', 'party': ''},
    color_discrete_map={'ČSSD': 'orange' ,
                'ODS':'blue', 
                'KSČM':'red', 
                'Piráti':'black', 
                'ANO':'aqua', 
                'STAN':'green',
                'SPD':'brown',
                'KDU-ČSL':'yellow',
                'TOP09':'purple',
                'Nezařaz':'pink'}
)

switched_animation.update_layout(xaxis={'categoryorder':'array', 
                                        'categoryarray':['ANO',
                                                         'ČSSD',
                                                         'ODS', 
                                                         'Nezařaz',
                                                         'SPD', 
                                                         'Piráti',
                                                         'KSČM',
                                                         'STAN',
                                                         'KDU-ČSL', 
                                                         'TOP09']})
pio.show(switched_animation)

Účast na hlasování (docházka) jednotlivých poslanců

V principu v celém tomhle přehazování s daty jen zjištujeme kolika hlasování se každý jednotlivý poslanec mohl zůčastnit (votes) a na kolika z nich chyběl (absence_votes).

Pak z takto získaných dat pro každého poslance vypočítáme procentuální absenci ( samozřejmě to není úplně fér vůči příchozím/odchozím poslancům, jelikož u nich se absence projeví procentuálně více )

votes = data.groupby(['member_id']).size().reset_index()

absence_votes = data[data['vote_code'] == '0']

absence_votes = absence_votes.groupby(['member_id']).size().reset_index()
absence = pd.merge(votes, absence_votes, on = 'member_id', how = 'left')


absence.rename(columns={'0_x': 'possible_voting', '0_y': 'absence_voting'}, inplace=True)
absence['absence_voting'].fillna(0, inplace=True)
absence['absence_percentage'] = round((absence['absence_voting'] / absence['possible_voting']) *100, 2)
absence_percentage = absence.drop(columns=['absence_voting', 'possible_voting'])

switched = list(switched_members['member_id'])

absence = pd.merge(absence, all_members_info, on = 'member_id') 
absence_percentage = pd.merge(absence_percentage, all_members_info, on = 'member_id') 

• Jelikož se jedná o celkovou absenci každého jednotlivého poslance tak vyvstává otázka do jaké strany zařadit přěbehlíky jestli do jejich první nebo poslední strany nebo do všech. Já jsem jim jednoduše vytvořil speciální kategorii

absence_percentage.loc[absence_percentage['member_id'].isin(switched), 'party'] = 'Přeběhlíci'

absence_percentage = absence_percentage.groupby(['member_name', 'party', 'absence_percentage']).size().reset_index()

absence_percentage = absence_percentage.drop(columns=[0])

parties = data['party'].unique()
parties[-1] = 'Přeběhlíci' 

party_colors = {'ČSSD': 'orange' ,
                'ODS':'blue', 
                'KSČM':'red', 
                'Piráti':'black', 
                'ANO':'aqua', 
                'STAN':'green',
                'SPD':'brown',
                'KDU-ČSL':'yellow',
                'TOP09':'purple',
                'Přeběhlíci':'pink'}

fig = make_subplots(
    rows=11, 
    cols=1,
    specs=[[{"rowspan": 2}],[None],[{}],[{}],[{}],[{}],[{}],[{}],[{}],[{}],[{}]],
    subplot_titles=([''.join((party, ' - absence jednotlivých členů')) for party in parties])
)

for i, party in enumerate(parties):
    row = i+1 if party == 'ANO' else i+2
    party_absence = absence_percentage[absence_percentage['party'] == party]
    
    fig.add_trace(go.Bar(
    name='% absence',
    y=party_absence['member_name'],
    x=party_absence['absence_percentage'],
    orientation='h'
    ),
    row=row
    ,col=1
    )
    
    fig.update_traces(marker_color = party_colors[party], row = row, col = 1)
    
    
fig.update_xaxes(range = [0,100], title_text = '% absence')
fig.update_layout(height = 10000, width = 800, showlegend = False)
fig.show()

• Později jsem ještě dodělal absenci v absolutních hodnotách, abych neznevýhoďnoval odchozí/příchozí poslance

absence.loc[absence['member_id'].isin(switched), 'party'] = 'Přeběhlíci'

absence = absence.groupby(['member_name', 'party', 'absence_voting', 'possible_voting']).size().reset_index()
absence = absence.drop(columns=[0])

absolute_member_absence = make_subplots(
    rows=11, 
    cols=1,
    specs=[[{"rowspan": 2}],[None],[{}],[{}],[{}],[{}],[{}],[{}],[{}],[{}],[{}]],
    subplot_titles=([''.join((party, ' - absence jednotlivých členů')) for party in parties])
)

for i, party in enumerate(parties):
    row = i+1 if party == 'ANO' else i+2
    party_absence = absence[absence['party'] == party]
    
    absolute_member_absence.add_trace(go.Bar(
    name='Absence',
    y=party_absence['member_name'],
    x=party_absence['absence_voting'],
    orientation='h',
    marker = {'color': 'gray'}
    ),
    row=row
    ,col=1
    )
    
    absolute_member_absence.add_trace(go.Bar(
    name='Přítomnost',
    y=party_absence['member_name'],
    x=party_absence['possible_voting'],
    orientation='h',
    marker = {'color' : party_colors.get(party)}
    ),
    row=row
    ,col=1
    )
    
#     absolute_member_absence.update_traces(marker_color = party_colors[party], row = row, col = 1)
    
    
absolute_member_absence.update_xaxes(title_text = 'celková přítomnost/absence')
absolute_member_absence.update_layout(height = 10000, width = 800, showlegend = False)
absolute_member_absence.show()

Účast na hlasování jednotlivých stran

• Opět zde počítáme procentuální absenci, takže nejdříve zjistíme celkový počet hlasů každé strany(party_votes), pak kolik z těchto hlasů byly absence(party_absence_votes) a nakonec vypočteme výsledná procenta(party_absence)

• Absence přeběhlíků je v tomto případě rozdělena mezi jednotlivé strany za něž byli poslanci. (Např. pokud byl poslanec členem strany A během prvních 10 hlasování z čehož 5 chyběl a následně přestoupil do strany B, kde již zůstal, tak jeho prvních 10 hlasování a 5 absencí je započítáno do celkové absence strany A a zbylé hlasování a absence jsou již započítány do celkové absence strany B)

party_votes = data.groupby(['party']).size().reset_index()

party_absence_votes = data[data['vote_code'] == '0']

party_absence_votes = party_absence_votes.groupby(['party']).size().reset_index()
party_absence = pd.merge(party_votes, party_absence_votes, on = 'party')

party_absence.rename(columns={'0_x': 'possible_voting', '0_y': 'absence_voting'}, inplace=True)
party_absence['absence_percentage']=round((party_absence['absence_voting'] / party_absence['possible_voting'])*100, 2)
party_absence_percentage = party_absence.drop(columns=['absence_voting', 'possible_voting'])

barchart = px.bar(
    data_frame=party_absence_percentage,
    
    x='party',
    y='absence_percentage',
    color='party',             
    opacity=1,                
    orientation='v',              
    barmode='relative',
    text = 'absence_percentage',
    title = 'Absence stran',
    labels={'absence_percentage':'% absence', 'party': ''}, 
    color_discrete_map={'ČSSD': 'orange' ,
                        'ODS':'blue', 
                        'KSČM':'red', 
                        'Piráti':'black', 
                        'ANO':'aqua', 
                        'STAN':'green',
                        'SPD':'brown',
                        'KDU-ČSL':'yellow',
                        'TOP09':'purple',
                        'Nazařaz':'pink'}
)

barchart.update_traces(showlegend=False)
barchart.update_layout(barmode='stack', xaxis={'categoryorder':'total descending'})



pio.show(barchart)

• Opět jsem pozdějí ještě doplnil graf, kde není informace zkreslená procenty.

absence_votes_graph = go.Figure()

for party in data['party'].unique():
    party_absence_filtered = party_absence[party_absence['party'] == party]
    
    

    absence_votes_graph = absence_votes_graph.add_traces(data=[
        go.Bar(name='Absence', 
               x=party_absence_filtered['party'], 
               y=party_absence_filtered['absence_voting'], 
               marker = {'color': 'gray'},
               width= 0.3,
               offset= - 0.3
              ),
        go.Bar(name='Možné hlasy', 
               x=party_absence_filtered['party'], 
               y=party_absence_filtered['possible_voting'], 
               marker = {'color' : party_colors.get(party)},
               width=0.3,
               offset = 0.0
              )
    ])

absence_votes_graph.update_layout(showlegend = False)
absence_votes_graph.show()

Jak často spolu jednotlivé strany hlasují ve shodě

• Pro každou stranu a každé hlasování nás zajímá kolik poslanců dané strany hlasovalo pro, kolik proti a kolik se zdrželo

• Maximum z těchto tří veličin budeme brát jako hlas strany v daném hlasování

• Za shodu mezi dvěma stranami pak považuji pouze to, když obě strany mají stejný hlas.

• Samožrejmě se tady dá argumentovat, že pokud se některá strana zdržela hlasování, tak vlastně tiše podpořila zamítnutí návrhu, protože ti kdo hlasovali pro nemohli dosáhnout nadpoloviční většiny hlasů. V tomto případě by se ale musel brát do úvahy ještě celkový počet přítomných poslanců a jeho poměr k počtu poslanců, kteří se hlasování zdrželi. Navíc je otázka jestli tento případ brát skutečně jako shodné hlasování.

• Já jsem se rozhodl to za shodné hlasování nepovažovat a tím si úlohu zjednodušil. Přislo mi ale fér to zde zmínit.

• Řešení úkolu tedy spočívá v zjištění jak daná strana hlasovala v každém jednotlivém hlasování. Dále porovnání všech dvojic stran pro každé hlasování a zjištění v kolika případech strany hlasovali stejně.

• Pak už je to jen převedené na mnou oblíbená procenta a vytvořena heatmapa.

def party_vote(sum_yes, sum_no, sum_abstained):
    votings_for = zip(sum_yes, sum_no, sum_abstained)
    result = []
    for row in votings_for: 
        yes = row[0]
        no = row[1]
        abstained = row[2]
        char_representation = {yes: 'A', no: 'N', abstained: 'Z'}
        result.append(char_representation.get(max(char_representation)))
    return result


target_party_votes = data.groupby(['meeting_id', 'voting_number', 'party', 'vote_code']).size().reset_index()

target_party_votes = target_party_votes[target_party_votes['vote_code'].isin(['A', 'N', 'Z'])]

target_party_votes.rename(columns={0: 'sum'}, inplace=True)

yes_votes = target_party_votes[target_party_votes['vote_code'] == 'A']
no_votes = target_party_votes[target_party_votes['vote_code'] == 'N']
abstained_votes = target_party_votes[target_party_votes['vote_code'] == 'Z']

target_party_votes = yes_votes.merge( no_votes, on=['meeting_id', 'voting_number', 'party'], how = 'outer', suffixes=('_yes', '_no'))\
                  .merge(abstained_votes, on=['meeting_id', 'voting_number', 'party'], how = 'outer')

target_party_votes = target_party_votes.drop(columns=['vote_code_no', 'vote_code_yes', 'vote_code'])
target_party_votes.rename(columns={'sum': 'sum_abstained'}, inplace=True)
target_party_votes['sum_yes'].fillna(0, inplace=True)
target_party_votes['sum_no'].fillna(0, inplace=True)
target_party_votes['sum_abstained'].fillna(0, inplace=True)
target_party_votes = target_party_votes.assign(vote_for = lambda x: party_vote(x.sum_yes, x.sum_no, x.sum_abstained))


target_party_votes = target_party_votes.drop(columns=['sum_yes','sum_no', 'sum_abstained'])




unique_parties = data['party'].unique() 

unique_votings = data.groupby(['meeting_id','voting_number']).size().reset_index().drop(columns=[0])


columns = {'Strany': unique_parties}

for party in unique_parties:
    percentages = []
    for other_party in unique_parties:
        first = target_party_votes[target_party_votes['party'] == party]
        second = target_party_votes[target_party_votes['party'] == other_party]
        
        joined = pd.merge(first, second, on = ['meeting_id', 'voting_number'])
        
        mutual_votings = len(joined)
        
        joined = joined[joined['vote_for_x'] == joined['vote_for_y']]
        
        mutual_votes = len(joined)
        
        percentages.append(round((mutual_votes / mutual_votings)*100, 2))
    
    columns[party] = percentages

df = pd.DataFrame(columns)

df = df.set_index(['Strany'])

df.index.name = None

# df

plt.figure(figsize=(14,10))

sns.heatmap(df, annot=True, fmt = 'g')
plt.show()

Jak často hlasují poslanci jednotlivých stran ve shodě + největší rebelové

• Zde pro každého poslance zjistíme jeho hlasy v jednotlivých hlasováních a pak porovnáme s hlasováním strany, které byl při daném hlasování členem.

• Počet shodných hlasů je uveden ve sloupci equal_votes a počet rozdílných hlasů ve sloupci rebel_votes.

target_party_votes

mutual_votes_members = pd.DataFrame(columns=['member_id', 'party', 'rebel_votes', 'equal_votes'])

for member in all_members:
    member_votes = data[ ( data['member_id'] == member ) & ( data['vote_code'].isin(['A', 'N', 'Z']))]
    member_votes = member_votes.drop(columns=['vote_id', 'member_name', 'member_id', 'day', 'month', 'year', 'hour', 'minute', 'date_time', 'voting_description'])
    member_parties = member_votes['party'].unique()
    
    for party in member_parties:
        member_votes_party = member_votes[member_votes['party'] == party]
        member_votes_party = member_votes_party.merge(target_party_votes, on = ['meeting_id', 'voting_number', 'party'])
        rebel_votes = member_votes_party[member_votes_party ['vote_code'] != member_votes_party ['vote_for']]
        equal_votes = member_votes_party[member_votes_party ['vote_code'] == member_votes_party ['vote_for']]
        mutual_votes_members = mutual_votes_members.append({'member_id': member, 'party': party, 'rebel_votes': len(rebel_votes), 'equal_votes': len(equal_votes)}, ignore_index=True)

mutual_votes_members = mutual_votes_members.merge(all_members_info, on = ['member_id', 'party'])
mutual_votes_members

	member_id	party	rebel_votes	equal_votes	member_name	0
0	6147	TOP09	370	4952	Markéta Pekarová Adamová	6821
1	4	ODS	906	4674	Marek Benda	6821
2	6149	KSČM	793	4770	Hana Aulická Jírovcová	6821
3	6150	ANO	295	1395	Andrej Babiš	6821
4	6661	ANO	4	141	Irena Blažková	276
...	...	...	...	...	...	...
216	6137	TOP09	432	4143	František Vácha	6821
217	6138	KDU-ČSL	544	3833	Pavel Bělobrádek	6821
218	6139	ANO	1186	4256	Josef Hájek	6821
219	305	KSČM	623	3966	Miroslav Grebeníček	6821
220	6143	ANO	302	6424	Stanislav Berkovec	6821

221 rows × 6 columns

Zde je již graf shodného hlasování resp. rebelských hlasů. Graf je rozdělen po jednotlivých stranách a měl by být seřazen podle počtu rebelských hlasů. Bohužel toto řazení mi kazí poslanci ze skupiny Nezařazení a Jaroslav Foldyna v ČSSD. Nepodařilo se mi přijít na to, proč je to zrovna v těchto případech rozhozeno.

rebel_voting=go.Figure()

for party in data['party'].unique():
    mutual_votes_members_filtered = mutual_votes_members[mutual_votes_members['party'] == party]
    mutual_votes_members_filtered = mutual_votes_members_filtered.sort_values(by = ['rebel_votes'])
    
    
    rebel_voting = rebel_voting.add_traces(data=[
        go.Bar(name='Rozdílné hlasy',
               x=mutual_votes_members_filtered['rebel_votes'], 
               y=[mutual_votes_members_filtered['party'], mutual_votes_members_filtered['member_name']], 
               orientation='h',
               marker = {'color': 'gray'},
               width= 0.2,
               offset = -0.4
              ),
        go.Bar(name='Shodné hlasy', 
               x=mutual_votes_members_filtered['equal_votes'], 
               y=[mutual_votes_members_filtered['party'], mutual_votes_members_filtered['member_name']], 
               orientation='h',
               marker = {'color' : party_colors.get(party)},
               width= 0.2
              )
    ])

rebel_voting.update_layout(height = 12000, width = 800, showlegend = False)
rebel_voting.show()

!jupyter nbconvert --to html homework_01_B201.ipynb

[NbConvertApp] Converting notebook homework_01_B201.ipynb to html